package com.logisticsrepair.config;

import lombok.Getter;
import lombok.Setter;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableAsync;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

@Configuration
@EnableAsync
@ConfigurationProperties(prefix = "task.pool")
@Setter
@Getter
public class ThreadPoolTaskConfig {
    /**
     * 线程创建执行流程：
     *
     * 默认情况下，在创建线程池后，线程池中的线程数为0，当有一个任务来的时候，就会在线程池中创建一个线程去执行任务。
     * 当线程池中的线程数量达到 corePoolSize 后，就会把之后的线程任务放到 缓存队列Queue中。
     * 当缓存队列满了后，依然会创建线程，当线程数量大于maxPoolSize之后，就会开始执行拒绝策略。
     */

    /**
     * 核心线程数（默认线程数）
     */
    private int corePoolSize;
    /**
     * 最大线程数
     */
    private int maxPoolSize;
    /**
     * 允许线程空闲时间（单位：默认为秒）
     */
    private int keepAliveTime;
    /**
     * 缓冲队列大小
     */
    private int queueCapacity;

    @Bean
    public ThreadPoolExecutor threadPoolExecutor(){
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(corePoolSize,
                maxPoolSize,
                keepAliveTime,
                TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(queueCapacity),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy());
        return threadPoolExecutor;
    }
}
